package cn.qicaiwang.open.qxyApi.server.Impl;


import cn.qicaiwang.open.common.utils.StringUtils;
import cn.qicaiwang.open.qxyApi.entity.TaxTaskResult;
import cn.qicaiwang.open.qxyApi.mapper.TaxTaskResultMapper;
import cn.qicaiwang.open.qxyApi.server.TaxTaskResultService;
import cn.qicaiwang.open.qxyApi.util.FileOperationUtils;
import cn.qicaiwang.open.qxyApi.util.IDCardUtils;
import cn.qicaiwang.open.qxyApi.util.JsonParserUtil;

import cn.qicaiwang.open.qxyApi.util.TaxReportNameUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;

@Service
public class TaxTaskResultServiceImpl extends ServiceImpl<TaxTaskResultMapper, TaxTaskResult>
        implements TaxTaskResultService {

    @Autowired
    private TaxTaskResultMapper taxTaskResultMapper;
    @Override
    public void saveOrUpdateTaskResult(String nsrsbh, String taskId,
                                       int requestCount, long totalTime,
                                       JSONObject responseJson,
                                       String mainStatus, String mainStatusCode,String userId,String entityName ) {


        Long totalTimeLong = totalTime;


        String responseJsonString = responseJson.toJSONString();



        LambdaQueryWrapper<TaxTaskResult> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TaxTaskResult::getNsrsbh, nsrsbh)
                .eq(TaxTaskResult::getTaskId, taskId);

        TaxTaskResult taskResult = this.getOne(queryWrapper);

        if (taskResult == null) {
            taskResult = new TaxTaskResult();
            taskResult.setNsrsbh(nsrsbh);
            taskResult.setTaskId(taskId);
        }

        // Update fields
        taskResult.setRequestCount(requestCount);
        taskResult.setTotalTime(totalTimeLong);
        taskResult.setResponseData(responseJsonString); // Store as String
        taskResult.setMainStatus(mainStatus);
        taskResult.setMainStatusCode(mainStatusCode);
        taskResult.setUserId(userId);
        taskResult.setEntityName(entityName);

        // Save or update
        this.saveOrUpdate(taskResult);
    }

    /**
     * 获取公司基本信息
     * @return
     */
    @Override
    public JSONObject taxCompanyEnterpriseInfoDtoPageResult(String id) {
        // 查询数据库中指定纳税人识别号的单个记录

        // 查询数据库中指定id的记录
        TaxTaskResult taxTaskResults = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造一个 JSONObject 来存储最终结果
        JSONObject resultJson = new JSONObject();



        // 如果查询结果为空，直接返回默认值
        if (taxTaskResults == null) {
            return resultJson;
        }

        String responseData = taxTaskResults.getResponseData();

        // 检查 responseData 是否为空
        if (responseData == null || responseData.trim().isEmpty()) {
            return resultJson;
        }

        // 动态路径（可以从配置文件或前端传递）
        String dynamicPath = "data.result.jcxx.taxCompanyEnterpriseInfoDtoPageResult";

        try {
            // 调用工具类方法解析 responseData
            Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

            // 检查解析结果类型
            if (parsedResult instanceof JSONObject) {
                JSONObject parsedJson = (JSONObject) parsedResult;
                String dbrzjhm = parsedJson.getString("dbrzjhm"); // 身份证号码
                String nsrmc = parsedJson.getString("nsrmc"); // 公司名称
                String dbrmc = parsedJson.getString("dbrmc"); // 法人
                Date createTime = taxTaskResults.getCreateTime();//报告创建日期
                // 将Date转换为字符串格式
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");


                int age = IDCardUtils.calculateAgeFromIDCard(dbrzjhm);
                resultJson.put("frnl", age); // 年龄
                resultJson.put("nsrmc", nsrmc); // 公司名称
                resultJson.put("dbrmc", dbrmc); // 法人
                resultJson.put("createTime", sdf.format(createTime));
            }



        } catch (Exception e) {
            // 捕获所有异常，保持默认值
        }

        return resultJson;
    }

    /**
     * 企业变更信息
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject taxCompanyEnterpriseChangeDtoPageResult(String id, Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过 id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 如果记录不存在，直接返回空结果
        if (taxTaskResult == null) {
            return new JSONObject().fluentPut("taxCompanyEnterpriseChangeDtoPageResult", new JSONArray());
        }

        // 2. 解析 responseData
        String responseData = taxTaskResult.getResponseData();
        JSONObject resultJson = new JSONObject();
        JSONArray taxCompanyEnterpriseChangeDtoPageResult = new JSONArray();

        // 动态路径（可以从配置文件或前端传递）
        String dynamicPath = "data.result.jcxx.taxCompanyEnterpriseChangeDtoPageResult";

        // 检查 responseData 是否为空
        if (responseData != null && !responseData.trim().isEmpty()) {
            try {
                // 调用工具类方法解析 responseData
                Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                // 如果解析结果是 JSONArray，直接赋值
                if (parsedResult instanceof JSONArray) {
                    taxCompanyEnterpriseChangeDtoPageResult = (JSONArray) parsedResult;
                }
                // 其他情况（如 JSONObject）可以按需处理
            } catch (Exception e) {
                // 记录日志（可选）
                // logger.error("解析 responseData 失败，id: " + id, e);
            }
        }

        // 3. 将解析结果存入 JSONObject
        resultJson.put("taxCompanyEnterpriseChangeDtoPageResult", taxCompanyEnterpriseChangeDtoPageResult);

        // 4. 分页处理
        return handleDataPage(resultJson, "taxCompanyEnterpriseChangeDtoPageResult", pageNum, pageSize);
    }

    /**
     * 纳税信用登记
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject taxCompanyCreditLevelDtoPageResult(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过 id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray taxCompanyCreditLevelDtoPageResult = new JSONArray();

        // 如果查询结果为空，直接返回空结果
        if (taxTaskResult == null) {
            resultJson.put("taxCompanyCreditLevelDtoPageResult", taxCompanyCreditLevelDtoPageResult);
            return handleDataPage(resultJson, "taxCompanyCreditLevelDtoPageResult", pageNum, pageSize);
        }

        // 动态路径
        String dynamicPath = "data.result.jcxx.taxCompanyCreditLevelDtoPageResult";
        String responseData = taxTaskResult.getResponseData();

        // 检查并解析responseData
        if (responseData != null && !responseData.trim().isEmpty()) {
            try {
                // 调用工具类方法解析responseData
                Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                // 处理解析结果
                if (parsedResult instanceof JSONArray) {
                    // 直接赋值解析结果
                    taxCompanyCreditLevelDtoPageResult = (JSONArray) parsedResult;
                } else if (parsedResult instanceof JSONObject) {
                    // 如果是单个对象，包装成数组
                    taxCompanyCreditLevelDtoPageResult.add(parsedResult);
                }
                // 其他类型可以在这里添加处理逻辑
            } catch (Exception e) {
                // 记录错误日志

            }
        }

        // 将结果存入JSON对象
        resultJson.put("taxCompanyCreditLevelDtoPageResult", taxCompanyCreditLevelDtoPageResult);

        // 分页处理并返回
        return handleDataPage(resultJson, "taxCompanyCreditLevelDtoPageResult", pageNum, pageSize);
    }
    /**
     * 纳税信用等级明细
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject taxCompanyCreditLevelDetailList(String id, Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过 id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray taxCompanyCreditLevelDetailList = new JSONArray();

        // 如果查询结果为空，直接返回空结果
        if (taxTaskResult == null) {
            resultJson.put("taxCompanyCreditLevelDetailList", taxCompanyCreditLevelDetailList);
            return handleDataPage(resultJson, "taxCompanyCreditLevelDetailList", pageNum, pageSize);
        }

        // 动态路径
        String dynamicPath = "data.result.jcxx.taxCompanyCreditLevelDetailList";
        String responseData = taxTaskResult.getResponseData();

        // 检查并解析responseData
        if (responseData != null && !responseData.trim().isEmpty()) {
            try {
                // 调用工具类方法解析responseData
                Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                // 处理解析结果
                if (parsedResult instanceof JSONArray) {
                    // 直接赋值解析结果
                    taxCompanyCreditLevelDetailList = (JSONArray) parsedResult;
                } else if (parsedResult instanceof JSONObject) {
                    // 如果是单个对象，包装成数组
                    taxCompanyCreditLevelDetailList.add(parsedResult);
                }
                // 其他类型可以在这里添加处理逻辑
            } catch (Exception e) {
                // 记录错误日志

            }
        }

        // 将结果存入JSON对象
        resultJson.put("taxCompanyCreditLevelDetailList", taxCompanyCreditLevelDetailList);

        // 分页处理并返回
        return handleDataPage(resultJson, "taxCompanyCreditLevelDetailList", pageNum, pageSize);
    }

    /**
     * 企业投资方信息
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject tzfxxDtoPageResult(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过 id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray tzfxxDtoPageResult = new JSONArray();

        // 如果查询结果为空，直接返回空结果
        if (taxTaskResult == null) {
            resultJson.put("tzfxxDtoPageResult", tzfxxDtoPageResult);
            return handleDataPage(resultJson, "tzfxxDtoPageResult", pageNum, pageSize);
        }

        // 动态路径
        String dynamicPath = "data.result.jcxx.tzfxxDtoPageResult";
        String responseData = taxTaskResult.getResponseData();

        // 检查并解析responseData
        if (responseData != null && !responseData.trim().isEmpty()) {
            try {
                // 调用工具类方法解析responseData
                Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                // 处理解析结果
                if (parsedResult instanceof JSONArray) {
                    // 直接赋值解析结果
                    tzfxxDtoPageResult = (JSONArray) parsedResult;
                } else if (parsedResult instanceof JSONObject) {
                    // 如果是单个对象，包装成数组
                    tzfxxDtoPageResult.add(parsedResult);
                }
                // 其他类型可以在这里添加处理逻辑
            } catch (Exception e) {
                // 记录错误日志

            }
        }

        // 将结果存入JSON对象
        resultJson.put("tzfxxDtoPageResult", tzfxxDtoPageResult);

        // 分页处理并返回
        return handleDataPage(resultJson, "tzfxxDtoPageResult", pageNum, pageSize);
    }

    @Override
    public JSONObject taxCompanyEnterpriseIllegalDtoPageResult(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)

        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray illegalInfoList = new JSONArray();

        // 2. 处理查询结果
        if (taxTaskResult != null) {
            String dynamicPath = "data.result.jcxx.taxCompanyEnterpriseIllegalDtoPageResult";
            String responseData = taxTaskResult.getResponseData();

            // 3. 解析responseData
            if (StringUtils.isNotBlank(responseData)) {
                try {
                    Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                    // 4. 处理解析结果
                    if (parsedResult instanceof JSONArray) {
                        illegalInfoList = (JSONArray) parsedResult;
                    } else if (parsedResult instanceof JSONObject) {
                        illegalInfoList.add(parsedResult);
                    } else {

                    }
                } catch (Exception e) {

                }
            }
        }

        // 5. 构造返回结果
        resultJson.put("taxCompanyEnterpriseIllegalDtoPageResult", illegalInfoList);

        // 6. 分页处理并返回
        return handleDataPage(resultJson, "taxCompanyEnterpriseIllegalDtoPageResult", pageNum, pageSize);
    }
    /**
     * 欠税信息
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject backTaxInfo(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（同时校验id和nsrsbh）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)

        );

        // 2. 准备返回结构
        JSONObject resultJson = new JSONObject();
        JSONArray taxInfoArray = new JSONArray();

        // 3. 处理查询结果
        if (taxTaskResult != null) {
            String dynamicPath = "data.result.jcxx.backTaxInfo";
            String responseData = taxTaskResult.getResponseData();

            if (StringUtils.isNotBlank(responseData)) {
                try {
                    // 4. 解析JSON数据
                    Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                    // 5. 统一处理解析结果（支持Array和Object两种格式）
                    if (parsedResult instanceof JSONArray) {
                        taxInfoArray = (JSONArray) parsedResult;
                    } else if (parsedResult instanceof JSONObject) {
                        taxInfoArray.add(parsedResult);
                    } else {

                    }
                } catch (Exception e) {

                }
            }
        }

        // 6. 构造返回结果
        resultJson.put("backTaxInfo", taxInfoArray);

        // 7. 分页处理
        return handleDataPage(resultJson, "backTaxInfo", pageNum, pageSize);
    }

    /**
     * 完税证明
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject taxCompanyPaymentListDtoPageResult(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray paymentList = new JSONArray();

        // 2. 处理查询结果
        if (taxTaskResult != null) {
            String dynamicPath = "data.result.jcxx.taxCompanyPaymentListDtoPageResult";
            String responseData = taxTaskResult.getResponseData();

            // 3. 检查并解析responseData
            if (responseData != null && !responseData.trim().isEmpty()) {
                try {
                    Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                    // 4. 处理解析结果
                    if (parsedResult instanceof JSONArray) {
                        paymentList = (JSONArray) parsedResult;
                    } else if (parsedResult instanceof JSONObject) {
                        paymentList.add(parsedResult);
                    }
                } catch (Exception e) {

                }
            }
        }

        // 5. 构造返回结果
        resultJson.put("taxCompanyPaymentListDtoPageResult", paymentList);

        // 6. 分页处理并返回
        return handleDataPage(resultJson, "taxCompanyPaymentListDtoPageResult", pageNum, pageSize);
    }

    /**
     * 税款征收信息
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject paymentInfo(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造一个 JSONObject 来存储结果
        JSONObject resultJson = new JSONObject();
        JSONArray paymentInfo = new JSONArray(); // 使用 JSONArray 来存储结果列表

        // 动态路径（可以从配置文件或前端传递）
        String dynamicPath = "data.result.jcxx.paymentInfo";

        // 修改为单条记录处理（仅移除了for循环，其他保持不变）
        if (taxTaskResult != null) {
            String responseData = taxTaskResult.getResponseData();

            // 检查 responseData 是否为空
            if (responseData == null || responseData.trim().isEmpty()) {
                // 记录日志或跳过该记录
            } else {
                Object parsedResult = null;
                try {
                    // 调用工具类方法解析 responseData
                    parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);
                } catch (Exception e) {
                    // 捕获解析异常并记录日志
                    // 例如：logger.error("解析 responseData 失败，nsrsbh: " + nsrsbh + ", responseData: " + responseData, e);
                }

                // 检查解析结果是否为 JSONArray 类型
                if (parsedResult instanceof JSONArray) {
                    JSONArray creditLevelArray = (JSONArray) parsedResult;
                    // 将解析到的列表添加到结果中
                    for (Object obj : creditLevelArray) { // 使用增强型 for 循环
                        if (obj instanceof JSONObject) {
                            paymentInfo.add(obj);
                        }
                    }
                } else {
                    // 如果解析结果不是 JSONArray，可以根据需要记录日志或处理其他情况
                    // 例如：logger.warn("解析结果不是 JSONArray 类型，nsrsbh: " + nsrsbh);
                }
            }
        }

        // 将结果列表存入最终的 JSON 对象
        resultJson.put("paymentInfo", paymentInfo);
        String dataFieldName = "paymentInfo";
        JSONObject jsonObject = handleDataPage(resultJson, dataFieldName, pageNum, pageSize);
        return jsonObject;
    }

    /**
     * 税费种认定
     * @param pageNum
     * @param pageSize
     * @return
     */
    @Override
    public JSONObject taxFeeIdentify(String id,  Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造一个 JSONObject 来存储结果
        JSONObject resultJson = new JSONObject();
        JSONArray taxFeeIdentify = new JSONArray(); // 使用 JSONArray 来存储结果列表

        // 动态路径（可以从配置文件或前端传递）
        String dynamicPath = "data.result.jcxx.taxFeeIdentify";

        // 修改为单条记录处理（仅移除了for循环，其他保持不变）
        if (taxTaskResult != null) {
            String responseData = taxTaskResult.getResponseData();

            // 检查 responseData 是否为空
            if (responseData == null || responseData.trim().isEmpty()) {
                // 记录日志或跳过该记录
            } else {
                Object parsedResult = null;
                try {
                    // 调用工具类方法解析 responseData
                    parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);
                } catch (Exception e) {
                    // 捕获解析异常并记录日志
                    // 例如：logger.error("解析 responseData 失败，nsrsbh: " + nsrsbh + ", responseData: " + responseData, e);
                }

                // 检查解析结果是否为 JSONArray 类型
                if (parsedResult instanceof JSONArray) {
                    JSONArray creditLevelArray = (JSONArray) parsedResult;
                    // 将解析到的列表添加到结果中
                    for (Object obj : creditLevelArray) { // 使用增强型 for 循环
                        if (obj instanceof JSONObject) {
                            taxFeeIdentify.add(obj);
                        }
                    }
                } else {
                    // 如果解析结果不是 JSONArray，可以根据需要记录日志或处理其他情况
                    // 例如：logger.warn("解析结果不是 JSONArray 类型，nsrsbh: " + nsrsbh);
                }
            }
        }

        // 将结果列表存入最终的 JSON 对象
        resultJson.put("taxFeeIdentify", taxFeeIdentify);
        String dataFieldName = "taxFeeIdentify";
        JSONObject jsonObject = handleDataPage(resultJson, dataFieldName, pageNum, pageSize);
        return jsonObject;
    }
    @Override
    public JSONObject getCustomerAndSupplierInfo(String id) {
        // 1. 查询数据库记录
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );
        // 2. 处理文件并分类结果
        return processAndMergeFiles(taxTaskResult);
    }

    /**
     * 处理单个文件并分类结果为进项和销项，并进一步加工Customer和Supplier数据
     * @param taxTaskResult
     * @return
     */
    private JSONObject processAndMergeFiles(TaxTaskResult taxTaskResult) {
        // 创建临时工作目录
        Path tempDir = Paths.get(System.getProperty("java.io.tmpdir"), "json_merge_" + System.currentTimeMillis());

        try {
            Files.createDirectories(tempDir);
            List<Path> validFiles = new ArrayList<>();

            // 处理单个任务结果
            if (taxTaskResult != null && StringUtils.isNotEmpty(taxTaskResult.getResponseData())) {
                processTaskResult(taxTaskResult, tempDir, validFiles);
            }

            // 获取文件（现在只有0或1个文件）
            List<Path> filesToProcess = validFiles.isEmpty() ? Collections.emptyList() : validFiles;

            // 合并JSON文件并分类
            if (filesToProcess.isEmpty()) {
                return new JSONObject().fluentPut("data", new JSONArray())
                        .fluentPut("inbound", new JSONArray()) // 进项
                        .fluentPut("outbound", new JSONArray()); // 销项
            }

            JSONObject mergedJson = FileOperationUtils.mergeJsonFiles(
                    filesToProcess.stream()
                            .map(Path::toString)
                            .collect(Collectors.toList())
            );

            // 分类进项和销项
            JSONArray dataArray = mergedJson.getJSONArray("data");
            JSONArray inboundArray = new JSONArray();
            JSONArray outboundArray = new JSONArray();

            if (dataArray != null) {
                for (int i = 0; i < dataArray.size(); i++) {
                    JSONObject invoice = dataArray.getJSONObject(i);
                    String jxxbz = invoice.getString("jxxbz");
                    if ("jx".equals(jxxbz)) {
                        inboundArray.add(invoice); // 进项
                    } else if ("xx".equals(jxxbz)) {
                        outboundArray.add(invoice); // 销项
                    }
                }
            }

            // 对进项和销项数据进行进一步加工
            JSONArray processedSupplierArray = processAndSortSupplierData(inboundArray);
            JSONArray processedCustomerArray = processAndSortCustomerData(outboundArray);

            // 返回分类后的结果
            return new JSONObject()
                    .fluentPut("Supplier", processedSupplierArray) // 进项数据（加工后）
                    .fluentPut("Customer", processedCustomerArray); // 销项数据（加工后）

        } catch (Exception e) {
            return new JSONObject().fluentPut("error", "文件处理异常");
        } finally {
            FileOperationUtils.deleteDirectory(tempDir.toFile());
        }
    }

    /**
     * 对Supplier数据进行加工处理，包括汇总、排序和添加排名字段、金额占比字段
     */
    private JSONArray processAndSortSupplierData(JSONArray inboundArray) {
        Map<String, Double> supplierPurchaseMap = new HashMap<>();
        double totalPurchase = 0.0;

        // 汇总每个供应商的采购金额
        for (int i = 0; i < inboundArray.size(); i++) {
            JSONObject invoice = inboundArray.getJSONObject(i);
            String xfmc = invoice.getString("xfmc"); // 购方名称
            double je = invoice.getDouble("je"); // 金额
            supplierPurchaseMap.put(xfmc, supplierPurchaseMap.getOrDefault(xfmc, 0.0) + je);
            totalPurchase += je;
        }

        // 将汇总结果转换为JSONArray，并排序
        List<JSONObject> supplierList = new ArrayList<>();
        for (Map.Entry<String, Double> entry : supplierPurchaseMap.entrySet()) {
            JSONObject supplier = new JSONObject();
            supplier.put("xfmc", entry.getKey());
            supplier.put("je", entry.getValue());
            supplierList.add(supplier);
        }

        supplierList.sort((o1, o2) -> Double.compare(o2.getDouble("je"), o1.getDouble("je"))); // 从大到小排序

        // 添加排名字段和金额占比字段（保留2位小数）
        JSONArray processedArray = new JSONArray();
        DecimalFormat df = new DecimalFormat("#.00"); // 保留2位小数的格式化器

        for (int i = 0; i < supplierList.size(); i++) {
            JSONObject supplier = supplierList.get(i);
            double percentage = (supplier.getDouble("je") / totalPurchase) * 100;

            supplier.put("rank", i + 1);
            supplier.put("percentage", Double.parseDouble(df.format(percentage))); // 格式化后转回double
            processedArray.add(supplier);
        }

        // 取前10个（如果需要）
        if (processedArray.size() > 10) {
            JSONArray limitedArray = new JSONArray();
            for (int i = 0; i < 10; i++) {
                limitedArray.add(processedArray.getJSONObject(i));
            }
            return limitedArray;
        } else {
            return processedArray;
        }
    }
    /**
     * 对Customer数据进行加工处理，包括汇总、排序和添加排名字段、金额占比字段
     */
    private JSONArray processAndSortCustomerData(JSONArray outboundArray) {
        Map<String, Double> customerSalesMap = new HashMap<>();
        double totalSales = 0.0;

        // 汇总每个客户的销售金额
        for (int i = 0; i < outboundArray.size(); i++) {
            JSONObject invoice = outboundArray.getJSONObject(i);
            String gfmc = invoice.getString("gfmc"); // 购方名称
            double je = invoice.getDouble("je");     // 金额
            customerSalesMap.put(gfmc, customerSalesMap.getOrDefault(gfmc, 0.0) + je);
            totalSales += je;
        }

        // 将汇总结果转换为JSONArray，并排序
        List<JSONObject> customerList = new ArrayList<>();
        for (Map.Entry<String, Double> entry : customerSalesMap.entrySet()) {
            JSONObject customer = new JSONObject();
            customer.put("gfmc", entry.getKey());
            customer.put("je", entry.getValue());
            customerList.add(customer);
        }

        // 按金额从大到小排序
        customerList.sort((o1, o2) -> Double.compare(o2.getDouble("je"), o1.getDouble("je")));

        // 添加排名字段和金额占比字段（保留2位小数）
        JSONArray processedArray = new JSONArray();
        DecimalFormat df = new DecimalFormat("#.00"); // 保留2位小数的格式化器

        for (int i = 0; i < customerList.size(); i++) {
            JSONObject customer = customerList.get(i);
            double percentage = totalSales == 0 ? 0 : (customer.getDouble("je") / totalSales) * 100;

            customer.put("rank", i + 1);
            customer.put("percentage", Double.parseDouble(df.format(percentage))); // 格式化后转回double
            processedArray.add(customer);
        }

        // 取前10个（如果需要）
        if (processedArray.size() > 10) {
            JSONArray limitedArray = new JSONArray();
            for (int i = 0; i < 10; i++) {
                limitedArray.add(processedArray.getJSONObject(i));
            }
            return limitedArray;
        }
        return processedArray;
    }

    /**
     * 对JSONArray进行排序并限制结果数量
     */
    private JSONArray sortAndLimit(JSONArray array, int limit) {
        if (array == null || array.isEmpty()) {
            return new JSONArray();
        }

        List<JSONObject> list = new ArrayList<>();
        for (int i = 0; i < array.size(); i++) {
            list.add(array.getJSONObject(i));
        }

        list.sort((o1, o2) -> {
            Double je1 = o1.getDouble("je");
            Double je2 = o2.getDouble("je");
            return je2.compareTo(je1); // 从大到小排序
        });

        // 取前limit个
        JSONArray sortedArray = new JSONArray();
        for (int i = 0; i < Math.min(limit, list.size()); i++) {
            sortedArray.add(list.get(i));
        }

        return sortedArray;
    }

    /**
     * 处理单个任务结果
     */
    private void processTaskResult(TaxTaskResult task, Path tempDir, List<Path> validFiles) {
        try {
            JSONObject parsedJson = (JSONObject) JsonParserUtil.parseResponseDataByPath(
                    task.getResponseData(),
                    "data.result.fp.jxxFileDownLoad"
            );

            if (parsedJson != null) {
                File zipFile = FileOperationUtils.downloadFile(parsedJson.getString("downloadLink"));
                List<Path> extractedFiles = FileOperationUtils.unzipAndFilterFiles(zipFile, tempDir);
                validFiles.addAll(extractedFiles);
                zipFile.delete();
            }
        } catch (Exception e) {
            // 忽略异常
        }
    }

    private List<Path> getLatest12Files(List<Path> files) {
        return files.stream()
                .filter(path -> {
                    try {
                        // 验证文件是否包含有效JSON
                        String content = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
                        return path.getFileName().toString().matches("^\\d{6}\\.json$") &&
                                (content.trim().startsWith("{") || content.trim().startsWith("["));
                    } catch (Exception e) {
                        return false;
                    }
                })
                .sorted((p1, p2) -> p2.getFileName().compareTo(p1.getFileName()))
                .limit(12)
                .collect(Collectors.toList());
    }
//------------------------------------------------------------------------------------------------------------------
@Override
public JSONObject getTaxBasicInfo( int year,String id) {
    TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
            new LambdaQueryWrapper<TaxTaskResult>()
                    .eq(TaxTaskResult::getId, id)
    );
    return getFormattedTaxData(taxTaskResult, year);
}

    @Override
    public JSONObject getFinancialReport(String id, Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray finRptList = new JSONArray();

        // 动态路径
        String dynamicPath = "data.result.sb.finRptList";

        // 处理单条记录
        if (taxTaskResult != null) {
            String responseData = taxTaskResult.getResponseData();

            // 检查并解析responseData
            if (StringUtils.isNotBlank(responseData)) {
                try {
                    Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                    // 处理解析结果
                    if (parsedResult instanceof JSONArray) {
                        JSONArray reportArray = (JSONArray) parsedResult;
                        for (Object obj : reportArray) {
                            if (obj instanceof JSONObject) {
                                JSONObject jsonObject = (JSONObject) obj;
                                String taxDm = jsonObject.getString("taxDm");
                                String reportName = TaxReportNameUtil.getReportNameByTaxDm(taxDm);
                                jsonObject.put("taxName", reportName); // 添加报表名称字段
                                finRptList.add(jsonObject);
                            }
                        }
                    }
                } catch (Exception e) {

                }
            }
        }

        // 分页处理并返回
        return handleDataPagination(finRptList, pageNum, pageSize);
    }

    @Override
    public JSONObject getTaxRptList(String id, Integer pageNum, Integer pageSize) {
        // 1. 查询单条记录（通过id）
        TaxTaskResult taxTaskResult = taxTaskResultMapper.selectOne(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .eq(TaxTaskResult::getId, id)
        );

        // 构造结果对象
        JSONObject resultJson = new JSONObject();
        JSONArray taxRptList = new JSONArray();

        // 动态路径
        String dynamicPath = "data.result.sb.taxRptList";

        // 处理单条记录
        if (taxTaskResult != null) {
            String responseData = taxTaskResult.getResponseData();

            // 检查并解析responseData
            if (StringUtils.isNotBlank(responseData)) {
                try {
                    Object parsedResult = JsonParserUtil.parseResponseDataByPath(responseData, dynamicPath);

                    // 处理解析结果
                    if (parsedResult instanceof JSONArray) {
                        JSONArray reportArray = (JSONArray) parsedResult;
                        for (Object obj : reportArray) {
                            if (obj instanceof JSONObject) {
                                JSONObject jsonObject = (JSONObject) obj;
                                String taxDm = jsonObject.getString("taxDm");
                                String reportName = TaxReportNameUtil.getReportNameByTaxDm(taxDm);
                                jsonObject.put("taxName", reportName); // 添加报表名称字段
                                taxRptList.add(jsonObject);
                            }
                        }
                    }
                } catch (Exception e) {

                }
            }
        }

        // 分页处理并返回
        return handleDataPagination(taxRptList, pageNum, pageSize);
    }

    public List<TaxTaskResult> getTaxTaskEntityNameInfo(String userId) {
        // 1. 查询该用户的所有记录（仅查询 entityName 和 nsrsbh 字段）
        List<TaxTaskResult> results = taxTaskResultMapper.selectList(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .select(TaxTaskResult::getEntityName, TaxTaskResult::getNsrsbh) // 只查询这两个字段
                        .eq(TaxTaskResult::getUserId, userId) // 按 userId 过滤
                        .orderByDesc(TaxTaskResult::getUpdateTime) // 按更新时间降序
        );

        // 2. 使用 Map 去重（基于 nsrsbh）
        Map<String, TaxTaskResult> uniqueEntries = new LinkedHashMap<>(); // 保持插入顺序

        for (TaxTaskResult result : results) {
            if (!uniqueEntries.containsKey(result.getNsrsbh())) {
                uniqueEntries.put(result.getNsrsbh(), result);
            }
        }

        return new ArrayList<>(uniqueEntries.values());
    }


    @Override
    public List<TaxTaskResult> getTaxReportByUserAndNsrsbh(String userId, String nsrsbh) {
        return taxTaskResultMapper.selectList(
                new LambdaQueryWrapper<TaxTaskResult>()
                        .select(TaxTaskResult::getId, TaxTaskResult::getCreateTime, TaxTaskResult:: getEntityName,TaxTaskResult:: getNsrsbh,TaxTaskResult:: getUserId) // 只查询这两个字段
                        .eq(TaxTaskResult::getUserId, userId)
                        .eq(TaxTaskResult::getNsrsbh, nsrsbh)
                        .orderByDesc(TaxTaskResult::getUpdateTime) // 最新数据在前
        );
    }

    @Override
    public JSONObject getSummary(String id, Integer pageNum, Integer pageSize) {
        // 企业涉税违法违章信息
        JSONObject taxCompanyEnterpriseIllegalDtoJsonObject = taxCompanyEnterpriseIllegalDtoPageResult(id, pageNum, pageSize);
        // 欠税信息
        JSONObject backTaxInfoDtoJsonObject = backTaxInfo(id, pageNum, pageSize);

        // 从两个JSON对象中提取total值
        int illegalCount = (taxCompanyEnterpriseIllegalDtoJsonObject != null) ? taxCompanyEnterpriseIllegalDtoJsonObject.getInteger("total") : 0;
        int backTaxCount = (backTaxInfoDtoJsonObject != null) ? backTaxInfoDtoJsonObject.getInteger("total") : 0;

        // 构建违法违章信息总结
        String illegalInfo;
        if (taxCompanyEnterpriseIllegalDtoJsonObject != null && illegalCount > 0) {
            JSONArray illegalRecords = taxCompanyEnterpriseIllegalDtoJsonObject.getJSONArray("taxCompanyEnterpriseIllegalDtoPageResult");
            boolean allProcessed = illegalRecords.stream().allMatch(record -> {
                JSONObject rec = (JSONObject) record;
                return "处理完毕".equals(rec.getString("wfwzztmc"));
            });

            if (allProcessed) {
                illegalInfo = String.format("贵企业历史涉税违法违章记录共计%d条，所有记录均已处理完毕。", illegalCount);
            } else {
                illegalInfo = String.format("贵企业历史涉税违法违章记录共计%d条，部分记录尚未处理完毕，请及时处理以降低潜在风险。", illegalCount);
            }
        } else {
            illegalInfo = "贵企业历史涉税违法违章记录为0条，表明贵企业在当前核查周期内暂无违法违规行为。";
        }

        // 构建欠税信息总结
        String backTaxInfo;
        if (backTaxInfoDtoJsonObject != null) {
            if (backTaxCount == 0) {
                backTaxInfo = "欠税信息显示为0条，表明贵企业在当前核查周期内暂无欠税情况，请继续保持税务申报与缴纳的及时性与准确性。";
            } else {
                backTaxInfo = String.format("欠税信息显示为%d条，请及时处理相关欠税事项，以避免产生滞纳金或其他法律后果。", backTaxCount);
            }
        } else {
            backTaxInfo = "欠税信息未提供，请确认相关数据是否完整。";
        }

        String summaryMessage = String.format("经核查，%s %s 为确保企业税务健康，建议定期开展税务合规性自查，并加强与税务机关的沟通，及时了解最新税收政策，以规避潜在税务风险。",
                illegalInfo, backTaxInfo);

        // 创建返回的JSON对象
        JSONObject summaryJSONObject = new JSONObject();
        summaryJSONObject.put("summary", summaryMessage);

        return summaryJSONObject;
    }

    @Override
    public Integer getReportCount(String userId) {
        Integer i=  taxTaskResultMapper.getReportCount(userId);
        return i;
    }

    @Override
    public void updateReportCount(String userId, int updatedCount) {
        taxTaskResultMapper.updateReportCount(userId,updatedCount);
    }

    private JSONObject handleDataPagination(Object data, Integer pageNum, Integer pageSize) {
        if (pageNum == null || pageNum < 1) {
            pageNum = 1;
        }
        if (pageSize == null || pageSize < 1) {
            pageSize = 10; // 默认每页 10 条
        }

        JSONArray itemsArray = null;
        JSONObject resultObj = new JSONObject();
        int total = 0;

        // 情况1：data是包含items数组的JSONObject
        if (data instanceof JSONObject) {
            JSONObject dataObj = (JSONObject) data;

            // 检查是否存在items数组
            if (dataObj.containsKey("items") && dataObj.get("items") instanceof JSONArray) {
                itemsArray = dataObj.getJSONArray("items");
                total = itemsArray.size();

                // 保留原始数据中的其他字段
                for (Map.Entry<String, Object> entry : dataObj.entrySet()) {
                    if (!"items".equals(entry.getKey())) {
                        resultObj.put(entry.getKey(), entry.getValue());
                    }
                }
            }
        }
        // 情况2：data本身就是JSONArray
        else if (data instanceof JSONArray) {
            itemsArray = (JSONArray) data;
            total = itemsArray.size();
        }

        // 计算分页范围
        int fromIndex = (pageNum - 1) * pageSize;
        int toIndex = Math.min(fromIndex + pageSize, total);

        // 处理超出范围的情况
        if (fromIndex >= total) {
            resultObj.put("items", new JSONArray());
            resultObj.put("total", total);
            resultObj.put("pageNum", pageNum);
            resultObj.put("pageSize", pageSize);
            return resultObj;
        }

        // 提取当前页数据并去除"resultData"字段
        JSONArray pagedItems = new JSONArray();
        for (int i = fromIndex; i < toIndex; i++) {
            JSONObject item = itemsArray.getJSONObject(i);
            if (item != null) {
                // 创建一个新的JSONObject来存储过滤后的数据
                JSONObject filteredItem = new JSONObject();
                for (String key : item.keySet()) {
                    if (!"resultData".equals(key)) {
                        filteredItem.put(key, item.get(key));
                    }
                }
                pagedItems.add(filteredItem);
            }
        }

        // 构建返回结果
        resultObj.put("items", pagedItems);
        resultObj.put("total", total);
        resultObj.put("pageNum", pageNum);
        resultObj.put("pageSize", pageSize);

        return resultObj;
    }



    private JSONObject getFormattedTaxData(TaxTaskResult taxTaskResult, int year) {
        // 获取当前年份数据
        JSONObject currentYearData = processAndFilterFilesByYear(taxTaskResult, year);
        JSONArray currentYearArray = currentYearData.getJSONArray("data");

        // 获取上年数据（用于同比计算）
        JSONObject lastYearData = processAndFilterFilesByYear(taxTaskResult, year - 1);
        JSONArray lastYearArray = lastYearData.getJSONArray("data");

        // 获取当前年月（用于处理未来月份）
        LocalDate now = LocalDate.now();
        int currentYear = now.getYear();
        int currentMonth = now.getMonthValue();

        // 初始化返回数据结构
        Map<String, Object> formattedData = new HashMap<>();
        List<List<String>> scrollData = new ArrayList<>();

        // 表格列头定义（11列固定格式）
        formattedData.put("fixedColumn", Arrays.asList(
                "月份",       // 格式：01月、02月...12月
                "开票",       // 当月有效发票数量（sfzsfp=0的发票）
                "同比",       // 与去年同月比较：↑增长 →持平 ↓下降
                "进项",       // 当月进项不含税金额（万元，保留1位小数）
                "销项",       // 当月销项不含税金额（万元，保留1位小数）
                "利润",       // 利润值：销项-进项（万元，保留1位小数，负值显示为0）
                "净税",     // 销项税额 - 进项税额（可抵扣部分），负值显示为0
                "税负",    // 销项税额与销项金额的比率（百分比，保留2位小数）
                "欠税"        // 默认值为0
        ));

        // 数据存储Map（当前年度）
        Map<String, Double> outputNoTaxAmount = new HashMap<>();  // 销项不含税金额（je字段）
        Map<String, Double> inputNoTaxAmount = new HashMap<>();   // 进项不含税金额（je字段）
        Map<String, Integer> invoiceCounts = new HashMap<>();     // 有效发票计数（jxxbz=xx且sfzsfp=0）
        Map<String, Double> outputTax = new HashMap<>();          // 销项税额（se字段）
        Map<String, Double> inputTax = new HashMap<>();           // 进项税额（se字段）
        Map<String, Integer> redInvoiceCounts = new HashMap<>();  // 销项红冲发票计数（jxxbz=xx且sfzsfp=1）

        // 数据存储Map（上年度，仅需销项数据用于同比）
        Map<String, Double> lastYearOutput = new HashMap<>();

        // 处理当前年数据（核心数据提取逻辑）
        if (currentYearArray != null) {
            for (int i = 0; i < currentYearArray.size(); i++) {
                JSONObject jsonObject = currentYearArray.getJSONObject(i);
                // 关键字段提取
                String kpyf = jsonObject.getString("kpyf");       // 开票月份（YYYYMM）
                String sfzsfp = jsonObject.getString("sfzsfp");   // 发票状态：0=有效，1=红冲
                String jxxbz = jsonObject.getString("jxxbz");    // 进销项标志：jx=进项，xx=销项
                double je = jsonObject.getDoubleValue("je");      // 金额
                double se = jsonObject.getDoubleValue("se");      // 税额

                // 只处理当年数据
                if (kpyf != null && kpyf.startsWith(String.valueOf(year))) {
                    String month = String.format("%02d月", Integer.parseInt(kpyf.substring(4, 6)));

                    // 红冲发票处理（保留但不展示）
                    if ("1".equals(sfzsfp) && "xx".equals(jxxbz)) {
                        redInvoiceCounts.merge(month, 1, Integer::sum);
                    }
                    // 有效发票处理（sfzsfp=0）
                    else if ("0".equals(sfzsfp)) {
                        // 销项数据处理
                        if ("xx".equals(jxxbz)) {
                            outputNoTaxAmount.merge(month, je, Double::sum);  // 累计销项金额
                            outputTax.merge(month, se, Double::sum);          // 累计销项税额
                            invoiceCounts.merge(month, 1, Integer::sum);      // 发票计数
                        }
                        // 进项数据处理
                        else if ("jx".equals(jxxbz)) {
                            inputNoTaxAmount.merge(month, je, Double::sum);   // 累计进项金额
                            inputTax.merge(month, se, Double::sum);           // 累计进项税额
                        }
                    }
                }
            }
        }

        // 处理上年数据（仅需销项数据用于同比计算）
        if (lastYearArray != null) {
            for (int i = 0; i < lastYearArray.size(); i++) {
                JSONObject jsonObject = lastYearArray.getJSONObject(i);
                String kpyf = jsonObject.getString("kpyf");
                String sfzsfp = jsonObject.getString("sfzsfp");
                if (kpyf != null && kpyf.startsWith(String.valueOf(year - 1)) && "0".equals(sfzsfp)) {
                    String month = String.format("%02d月", Integer.parseInt(kpyf.substring(4, 6)));
                    double je = jsonObject.getDoubleValue("je");
                    if ("xx".equals(jsonObject.getString("jxxbz"))) {
                        lastYearOutput.merge(month, je, Double::sum);  // 去年销项金额
                    }
                }
            }
        }

        // 构建每月数据行（1-12月）
        for (int month = 1; month <= 12; month++) {
            String monthStr = String.format("%02d月", month);
            List<String> row = new ArrayList<>();

            // 1. 月份列（固定格式）
            row.add(monthStr);

            // 2. 开票数量列（当月有效销项发票数）
            int invoiceCount = invoiceCounts.getOrDefault(monthStr, 0);
            row.add(String.valueOf(invoiceCount > 0 ? invoiceCount : 0));

            // 3. 同比计算列（与去年同月比较）
            String yoy = "0";
            if (year != currentYear || month <= currentMonth) {
                double currentOutput = outputNoTaxAmount.getOrDefault(monthStr, 0.0);
                double lastOutput = lastYearOutput.getOrDefault(monthStr, 0.0);

                if (lastOutput > 0) {
                    if (currentOutput > lastOutput) yoy = "↑";
                    else if (currentOutput < lastOutput) yoy = "↓";
                    else yoy = "→";
                } else if (currentOutput > 0) {
                    yoy = "↑";
                }
            }
            row.add(yoy);

            // 4. 进项列（不含税金额，单位：万元）
            double inputAmount = inputNoTaxAmount.getOrDefault(monthStr, 0.0);
            row.add(String.format("%.1f", inputAmount / 10000));

            // 5. 销项列（不含税金额，单位：万元）
            double outputAmount = outputNoTaxAmount.getOrDefault(monthStr, 0.0);
            row.add(String.format("%.1f", outputAmount / 10000));

            // 6. 利润列（销项-进项，负值显示为0）
            String profitValue = "0";
            if (year != currentYear || month <= currentMonth) {
                double output = outputNoTaxAmount.getOrDefault(monthStr, 0.0);
                double input = inputNoTaxAmount.getOrDefault(monthStr, 0.0);
                double profit = output - input;
                profitValue = profit > 0 ? String.format("%.1f", profit / 10000) : "0";
            }
            row.add(profitValue);

            // 进项税额列（进项税额，单位：万元）
            double inputTaxAmount = inputTax.getOrDefault(monthStr, 0.0);


            //  销项税额列（销项税额，单位：万元）
            double outputTaxAmount = outputTax.getOrDefault(monthStr, 0.0);


            // 7. 净税额列（销项税额 - 进项税额，负值显示为0）
            String netTaxValue = "0";
            if (year != currentYear || month <= currentMonth) {
                double netTax = outputTaxAmount - inputTaxAmount;
                netTaxValue = netTax > 0 ? String.format("%.1f", netTax / 10000) : "0";
            }
            row.add(netTaxValue);

            // 10. 税负率列（销项税额/销项金额*100%）
            String taxRate = "0.00%";
            if (year != currentYear || month <= currentMonth) {
                if (outputAmount > 0 && outputTaxAmount > 0) {
                    double rate = (outputTaxAmount / outputAmount) * 100;
                    taxRate = String.format("%.2f%%", rate);
                }
            }
            row.add(taxRate);

            // 11. 欠税列（默认值为0）
            row.add("0");

            scrollData.add(row);
        }

        formattedData.put("scrollData", scrollData);
        return new JSONObject(formattedData);
    }
    /**
     * 处理文件并分类结果为包含指定年份的税务基本信息，并过滤出有效数据（包括销项和进项）
     */
    private JSONObject processAndFilterFilesByYear(TaxTaskResult taxTaskResult, int year) {
        // 创建临时工作目录
        Path tempDir = Paths.get(System.getProperty("java.io.tmpdir"), "json_merge_" + System.currentTimeMillis());

        try {
            Files.createDirectories(tempDir);
            List<Path> validFiles = new ArrayList<>();

            // 用于统计每个月的文件数量
            Map<String, Integer> monthlyFileCount = new HashMap<>(); // Key: "202501", "202502", ..., Value: 文件数量

            // 处理单个任务结果
            if (taxTaskResult != null && StringUtils.isNotEmpty(taxTaskResult.getResponseData())) {
                processTaskResult(taxTaskResult, tempDir, validFiles);
            }

            // 筛选包含指定年份的 JSON 文件
            List<Path> filesForYear = getFilesForYearByName(validFiles, year);

            // 统计每个月的文件数量
            for (Path file : filesForYear) {
                try {
                    String fileName = file.getFileName().toString();
                    if (fileName.startsWith(String.valueOf(year)) && fileName.endsWith(".json")) {
                        String monthKey = fileName.substring(0, 6); // 提取 "202501", "202502" 等
                        monthlyFileCount.put(monthKey, monthlyFileCount.getOrDefault(monthKey, 0) + 1);
                    }
                } catch (Exception e) {
                    // 忽略异常，继续处理其他文件
                }
            }

            // 打印每个月的文件数量
            System.out.println("Year: " + year);
            for (int month = 1; month <= 12; month++) {
                String monthKey = String.format("%d%02d", year, month); // 格式化为 "202501", "202502" 等
                int count = monthlyFileCount.getOrDefault(monthKey, 0);
                System.out.println("Month: " + monthKey + ", File Count: " + count);
            }

            // 合并 JSON 文件
            if (filesForYear.isEmpty()) {
                return new JSONObject().fluentPut("data", new JSONArray());
            }

            JSONObject mergedJson = FileOperationUtils.mergeJsonFiles(
                    filesForYear.stream()
                            .map(Path::toString)
                            .collect(Collectors.toList())
            );

            // 修改此处：不再过滤数据，保留所有原始数据
            JSONArray originalData = mergedJson.getJSONArray("data");

            // 返回原始结果（包含销项和进项）
            return new JSONObject()
                    .fluentPut("data", originalData != null ? originalData : new JSONArray());

        } catch (Exception e) {
            return new JSONObject().fluentPut("error", "文件处理异常");
        } finally {
            try {
                FileOperationUtils.deleteDirectory(tempDir.toFile());
            } catch (Exception e) {
                e.printStackTrace(); // 处理删除目录时的异常
            }
        }
    }
    /**
     * 筛选解压后的文件中包含指定年份的 JSON 文件（通过文件名判断）
     */
    private List<Path> getFilesForYearByName(List<Path> files, int year) {
        String yearStr = String.valueOf(year); // 将年份转换为字符串
        return files.stream()
                .filter(path -> {
                    try {
                        // 获取文件名
                        String fileName = path.getFileName().toString();
                        // 检查文件名是否包含指定年份
                        return fileName.contains(yearStr) && fileName.endsWith(".json");
                    } catch (Exception e) {
                        return false; // 如果发生异常，则跳过该文件
                    }
                })
                .collect(Collectors.toList());
    }

    /**
     * 对 JSON 数据进行分页处理
     *
     * @param resultJson 可能是包含所有数据的 JSON 对象，也可能是已经分页的 JSON 对象
     * @param dataFieldName 包含数据数组的字段名
     * @param pageNum 当前页码，从 1 开始
     * @param pageSize 每页显示的数据数量
     * @return 分页后的 JSON 对象
     */
    private JSONObject handleDataPage(JSONObject resultJson, String dataFieldName, Integer pageNum, Integer pageSize) {
        // 检查分页参数是否有效
        if (pageNum == null || pageNum <= 0 || pageSize == null || pageSize <= 0) {
            throw new IllegalArgumentException("分页参数 pageNum 和 pageSize 必须大于 0");
        }

        // 检查数据字段名是否有效
        if (dataFieldName == null || dataFieldName.trim().isEmpty()) {
            throw new IllegalArgumentException("数据字段名不能为空");
        }

        // 尝试获取数据数组字段
        JSONArray originalDataArray = resultJson.getJSONArray(dataFieldName);

        // 如果找不到指定字段，检查是否是多个JSONObject的情况
        if (originalDataArray == null) {
            // 检查resultJson是否已经是分页后的格式（包含total/pageNum/pageSize等字段）
            if (resultJson.containsKey("total") || resultJson.containsKey("pageNum") || resultJson.containsKey("pageSize")) {
                // 如果已经是分页格式，直接返回
                return resultJson;
            }

            // 如果不是分页格式，尝试将整个resultJson视为一个数据项
            JSONObject emptyResult = new JSONObject();
            emptyResult.put(dataFieldName, new JSONArray());
            emptyResult.put("total", 0);
            emptyResult.put("pageNum", pageNum);
            emptyResult.put("pageSize", pageSize);
            return emptyResult;
        }

        // 处理原始数据为空的情况
        if (originalDataArray.isEmpty()) {
            JSONObject emptyResult = new JSONObject();
            emptyResult.put(dataFieldName, new JSONArray());
            emptyResult.put("total", 0);
            emptyResult.put("pageNum", pageNum);
            emptyResult.put("pageSize", pageSize);
            return emptyResult;
        }

        // 计算总记录数
        int total = originalDataArray.size();

        // 计算分页起始索引和结束索引
        int fromIndex = (pageNum - 1) * pageSize;
        int toIndex = Math.min(fromIndex + pageSize, total);

        // 检查起始索引是否超出范围
        if (fromIndex >= total) {
            JSONObject emptyResult = new JSONObject();
            emptyResult.put(dataFieldName, new JSONArray());
            emptyResult.put("total", total);
            emptyResult.put("pageNum", pageNum);
            emptyResult.put("pageSize", pageSize);
            return emptyResult;
        }

        // 提取分页后的数据
        JSONArray paginatedDataArray = new JSONArray();
        for (int i = fromIndex; i < toIndex; i++) {
            paginatedDataArray.add(originalDataArray.get(i));
        }

        // 构造分页后的 JSON 对象
        JSONObject paginatedResult = new JSONObject();
        paginatedResult.put(dataFieldName, paginatedDataArray);
        paginatedResult.put("total", total);
        paginatedResult.put("pageNum", pageNum);
        paginatedResult.put("pageSize", pageSize);

        return paginatedResult;
    }



}